home *** CD-ROM | disk | FTP | other *** search
/ 220 Jogos / 220 jogos.iso / classicos / resta11 / STree.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-12-24  |  5.8 KB  |  308 lines
  1. // STree.cpp: Implementierung der Klasse STree.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  4.  
  5. #include "stdafx.h"
  6. #include "STree.h"
  7.  
  8. #include <math.h>
  9. #include <stdlib.h>
  10.  
  11.  
  12. #ifdef _DEBUG
  13. #undef THIS_FILE
  14. static char THIS_FILE[]=__FILE__;
  15. #define new DEBUG_NEW
  16. #endif
  17.  
  18. #define ROT_SPEED 0.005f
  19. #define ROT_MAX 15.0f
  20. #define ROT_DIMINUATION 1.005f
  21. #define SHRINK_SPEED -0.0005f
  22. #define FLY_SPEED 0.01f
  23.  
  24.  
  25. enum
  26. {
  27.     DESTR_FLYING,
  28.     DESTR_SHRINKING
  29. };
  30.  
  31.  
  32. //////////////////////////////////////////////////////////////////////
  33. // Konstruktion/Destruktion
  34. //////////////////////////////////////////////////////////////////////
  35.  
  36. STree::STree()
  37. {
  38.     quadric = NULL;
  39.     position[0] = 0.0f;
  40.     position[1] = 0.0f;
  41.     position[2] = 0.0f;
  42.     treeState = STATE_SHOWN;
  43.     matrixPos[0] = 0;
  44.     matrixPos[1] = 0;
  45.     rotation[0] = 0.0f;
  46.     rotation[1] = 0.0f;
  47.     rotSpeed[0] = 0.0f;
  48.     rotSpeed[1] = 0.0f;
  49.     lastRealPos[0] = 0.0f;
  50.     lastRealPos[1] = 0.0f;
  51.     size = 1.0f;
  52.     destructionMethod = 0;
  53. }
  54.  
  55. STree::~STree()
  56. {
  57.     if (quadric)
  58.     {
  59.         gluDeleteQuadric(quadric);
  60.     }
  61. }
  62.  
  63. bool STree::create(STexture* texBaum, STexture* texStamm)
  64. {
  65.     baum = texBaum;
  66.     stamm = texStamm;
  67.  
  68.     quadric = gluNewQuadric();
  69.     gluQuadricTexture(quadric,GL_TRUE);
  70.     gluQuadricNormals(quadric,GL_SMOOTH);
  71.     
  72.     return true;
  73. }
  74.  
  75. void STree::setPosition(float x, float y, float z)
  76. {
  77.     lastRealPos[0] = position[0];
  78.     lastRealPos[1] = position[1];
  79.     position[0] = x;
  80.     position[1] = y;
  81.     position[2] = z;
  82. }
  83.  
  84. void STree::update(float frametime)
  85. {
  86.     if (treeState == STATE_HIDDEN)
  87.     {
  88.         return;
  89.     }
  90.     else if (treeState == STATE_DRAGGING)
  91.     {
  92.         rotSpeed[0] += (lastRealPos[1] - position[1])/80.0f;
  93.         rotSpeed[1] -= (lastRealPos[0] - position[0])/80.0f;
  94.  
  95.         rotation[0] += rotSpeed[0]*frametime;
  96.         rotation[1] += rotSpeed[1]*frametime;
  97.  
  98.         if (fabs(rotation[0]) >= ROT_MAX)
  99.         {
  100.             rotSpeed[0] /= -ROT_DIMINUATION;
  101.         }
  102.  
  103.         if (fabs(rotation[1]) >= ROT_MAX)
  104.         {
  105.             rotSpeed[1] /= -ROT_DIMINUATION;
  106.         }
  107.  
  108.         rotation[0] /= ROT_DIMINUATION;
  109.         rotation[1] /= ROT_DIMINUATION;
  110.         
  111.         rotSpeed[0] /= ROT_DIMINUATION;
  112.         rotSpeed[1] /= ROT_DIMINUATION;
  113.  
  114.  
  115.         /*rotSpeed[0] += (rotSpeed[0] < 0 ? 1.0f : -1.0f)*ROT_DIMINUATION*frametime;
  116.         rotSpeed[1] += (rotSpeed[1] < 0 ? 1.0f : -1.0f)*ROT_DIMINUATION*frametime;*/
  117.     }
  118.     else if (treeState == STATE_DESTROYING)
  119.     {
  120.         switch (destructionMethod)
  121.         {
  122.         case DESTR_SHRINKING:
  123.             size += SHRINK_SPEED*frametime;
  124.  
  125.             if (size <= 0.2f)
  126.             {
  127.                 treeState = STATE_HIDDEN;
  128.             }
  129.             break;
  130.         case DESTR_FLYING:
  131.             position[2] += FLY_SPEED*frametime;
  132.  
  133.             if (position[2] >= 25.0f)
  134.             {
  135.                 treeState = STATE_HIDDEN;
  136.             }
  137.             break;
  138.         }
  139.     }
  140.  
  141.     draw();
  142. }
  143.  
  144. void STree::draw()
  145. {
  146.     ////////////////
  147.     // ZEICHNEN
  148.     ////////////////
  149.  
  150.     glPushMatrix();
  151.  
  152.     //Position des Baums
  153.     glTranslatef(position[0],position[1],
  154.         position[2] + (treeState == STATE_DRAGGING ? 0.75f : 0.0f));
  155.     
  156.     //Wankel des Baums
  157.     if (treeState == STATE_DRAGGING)
  158.     {
  159.         glRotatef(rotation[0],1.0f,0.0f,0.0f);
  160.         glRotatef(rotation[1],0.0f,1.0f,0.0f);
  161.     }
  162.     else if (treeState == STATE_DESTROYING && 
  163.         destructionMethod == DESTR_SHRINKING)
  164.     {
  165.         glScalef((size < 0.2f ? 0.2f:size),(size < 0.2f ? 0.2f:size),
  166.             (size < 0.2f ? 0.2f:size));
  167.     }
  168.     
  169.  
  170.     //**Baumwipfel**
  171.  
  172.     baum->select();
  173.     //Ein bisschen zurⁿck damit dass auch richtig gezeichnet wird;)
  174.     glTranslatef(0.0f,0.0f,-BAUM_HOEHE);
  175.     gluCylinder(quadric,BAUM_BREITE,0.0f,BAUM_HOEHE,20,4);
  176.  
  177.     //**Baumstamm**
  178.  
  179.     stamm->select();
  180.  
  181.     glTranslatef(0.0f,0.0f,-STAMM_HOEHE);
  182.     gluCylinder(quadric,STAMM_BREITE,STAMM_BREITE,STAMM_HOEHE,20,4);
  183.  
  184.     glPopMatrix();
  185. }
  186.  
  187.  
  188. bool STree::click(float x, float y)
  189. {
  190.     if (treeState == STATE_HIDDEN)
  191.     {
  192.         return false;
  193.     }
  194.  
  195.     if (x >= position[0]-BAUM_BREITE && x <= position[0]+BAUM_BREITE &&
  196.         y >= position[1]-BAUM_BREITE && y <= position[1]+BAUM_BREITE)
  197.     {
  198.         setState(STATE_DRAGGING);
  199.  
  200.         /*lastPos[0] = matrixPos[0];
  201.         lastPos[1] = matrixPos[1];*/
  202.  
  203.         return true;
  204.     }
  205.  
  206.     return false;
  207. }
  208.  
  209. void STree::setState(STreeState state)
  210. {
  211.     if (state == STATE_DRAGGING)
  212.     {
  213.         rotSpeed[0] = ROT_SPEED;
  214.     }
  215.     else if (state == STATE_DESTROYING)
  216.     {
  217.         destructionMethod = rand() % 2;
  218.         size = 1.0f;
  219.         position[2] = 0.0f;
  220.     }
  221.  
  222.     treeState = state;
  223. }
  224.  
  225. int STree::getXMatrixPos()
  226. {
  227.     return matrixPos[0];
  228. }
  229.  
  230. int STree::getYMatrixPos()
  231. {    
  232.     return matrixPos[1];
  233. }
  234.  
  235. int* STree::resolveFinalPos(float xTest, float yTest)
  236. {
  237.     static int possibility[2] = {0};
  238.  
  239.     possibility[0] = 0;
  240.     possibility[1] = 0;
  241.  
  242.     //** MATRIX POS RAUSKRIEGEN
  243.  
  244.     
  245.  
  246.     if (!(xTest <= -3.0f*SPACE-SPACE*0.5f || xTest >= 3.0f*SPACE+SPACE*0.5f || 
  247.             yTest >= 3.0f*SPACE+SPACE*0.5f || yTest <= -3.0f*SPACE-SPACE*0.5f))
  248.     {
  249.         for (float x = -3.0f*SPACE; x <= 3.0f*SPACE; x += SPACE)
  250.         {
  251.             possibility[1] = 0;
  252.  
  253.             for (float y = 3.0f*SPACE; y >= -3.0f*SPACE; y -= SPACE)
  254.             {
  255.                 if (xTest >= x-SPACE*0.5f && xTest <= x+SPACE*0.5f &&
  256.                     yTest >= y-SPACE*0.5f && yTest <= y+SPACE*0.5f)
  257.                 {    
  258.                     if ((possibility[0] < 2 && possibility[1] < 2) ||
  259.                         (possibility[0] > 4 && possibility[1] < 2) ||
  260.                         (possibility[0] < 2 && possibility[1] > 4) ||
  261.                         (possibility[0] > 4 && possibility[1] > 4))
  262.                     {
  263.                         possibility[0] = -1;
  264.                         possibility[1] = -1;
  265.                     }    
  266.                 
  267.                     return possibility;
  268.                 }
  269.  
  270.                 possibility[1] += 1;
  271.             }
  272.             
  273.             possibility[0] += 1;
  274.         }
  275.     }
  276.     else
  277.     {
  278.         possibility[0] = -1;
  279.         possibility[1] = -1;
  280.     }
  281.  
  282.         
  283.     return possibility;
  284. }
  285.  
  286. void STree::setFinalPos(int xTest, int yTest)
  287. {
  288. /*    lastPos[0] = matrixPos[0];
  289.     lastPos[1] = matrixPos[1];*/
  290.     
  291.     setPosition(
  292.         (xTest*6*SPACE)/6 - (3.0f*SPACE),
  293.         -((yTest*6*SPACE)/6) + (3.0f*SPACE),0.0f);
  294.  
  295.     matrixPos[0] = xTest;
  296.     matrixPos[1] = yTest;
  297. }
  298.  
  299. //DEL int* STree::getLastPos()
  300. //DEL {
  301. //DEL     return lastPos;
  302. //DEL }
  303.  
  304. STreeState STree::getState()
  305. {
  306.     return treeState;
  307. }
  308.